/** 
 * @main	Plik z definicjami generatorow.
 * @file    generatory.cpp
 * @author  Grzegorz Sejnota
 *
 * @created on 25 luty 2009, 13:41
 * @version 0.0001
 */

#include "generatory.h"
#include <string>
#include <cmath>
#include <sstream>
#include "wyjatki.h"
#include <boost\lexical_cast.hpp>
using namespace std;

bool Generator::sprawdzPoprawnoscMapy(const std::map<std::string,std::string> &mapa) {
   std::map<std::string,std::string>::iterator it = konfiguracja.begin();
   //----- sprawdzenie poprawnosci kluczy mapy --------------------------------
   for (; it != konfiguracja.end(); ++it) {
      if ((mapa.find(it->first) == mapa.end()) && (it->first != "[nazwa]=") && (it->first != "[typ]="))
	 return 0;
   }
   return 1;
}

   std::map<std::string, std::string> Generator::pobierzParam() const{
       return konfiguracja;
    };


    
	
std::map<std::string,int> Generator::pobierzDostepneGeneratory() {
   std::map<std::string,int> generatory;
   generatory["Losowy"] = Generatory::Losowy;
   generatory["Prostokat"] = Generatory::Prostokat;
   generatory["Trojkat"] = Generatory::Trojkat;
   generatory["Impuls"] = Generatory::Impuls;
   generatory["Sinus"] = Generatory::Sinus;
   generatory["Skok"] = Generatory::Skok;
   return generatory;
}
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZ�TEK [definicji klasy GeneratorLosowy] ++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//======= definicja skladnika statycznego liczbaGeneratorowLosowych ============
/**
 * Skladnik statyczny do przechowywania aktualnej liczby obiektow 
 * GeneratoraLosowego
 */
int GeneratorLosowy :: liczbaGeneratorowLosowych = 0;

//======= konstruktor  =========================================================
/**
 * Konstruktor klasy Generator Losowy.
 *      @param wariancja - zadana wariancja sygnalu losowego
 */
GeneratorLosowy::GeneratorLosowy (double war) : wariancja(0){
	this->wariancja = war;
	liczbaGeneratorowLosowych++;
	stringstream strumien;
    strumien<<liczbaGeneratorowLosowych;
    this->nazwa = "losowy" + strumien.str();
    konfiguracja["[nazwa]="] = this->nazwa;
    konfiguracja["[typ]="] = "Losowy";
    konfiguracja["[war]="] = "0";
}

//======= konstruktor kopiujacy ================================================
/**
 * Konstruktor kopiujacy klasy Generator Losowy.
 *      @param &wzor - referencja do obiektu klasy GeneratorLosowy, 
					   kt�ry ma by� skopiowany.
 */
GeneratorLosowy::GeneratorLosowy (const GeneratorLosowy & wzor){
	this->wariancja = wzor.wariancja;
	liczbaGeneratorowLosowych++;
	stringstream strumien;
    strumien<<liczbaGeneratorowLosowych;
    this->nazwa = "losowy" + strumien.str();
}

//======= destruktor  ==========================================================
/**
 * Destruktor klasy GeneratorLosowy - aktualizuje liczbe obiektow GeneratorLosowy.
 */
GeneratorLosowy :: ~GeneratorLosowy(){
    liczbaGeneratorowLosowych--;
}

//======= funkcja generuj ======================================================
/**
 * Funkcja generujaca probke sygnalu losowego o zadanej wariancji.
 *      @return probka generowanego sygnalu
 */
double GeneratorLosowy::generuj(){
	double granica = sqrt(3.0)*wariancja;
	return static_cast<double>( rand() ) / (static_cast<double> (RAND_MAX) + 1.0) 
                *2*granica - granica;
}

//======= funkcja pobierzNazwe =================================================
/**
 * Funkcja zwracajaca nazwe obiektu klasy GeneratorLosowy.
 *      @return nazwa
 */
std::string GeneratorLosowy::pobierzNazwe() const{
	return nazwa;
}
    
//======= funkcja reset ========================================================
/**
 * Funkcja zwracajaca resetujaca generator. Dla GeneratorLosowy jest pusta, wymagana
 * przez interfejs klasy Generator.
 */
void GeneratorLosowy::reset(){}


void GeneratorLosowy::ustawParam(std::map<std::string, std::string> konfig) {
   double tymczWar;
   std::map<std::string,std::string>::iterator it;

   if(!sprawdzPoprawnoscMapy(konfig)) {
      throw Wyjatek("Blad w funkcji ustawParam w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!"
		       + "\n Brak klucza:" + it->first);
   }
   
   for (it = konfig.begin(); it != konfig.end(); ++it) {
      try {
	 if ((it->first) == ("[war]=")) 
		 tymczWar = boost::lexical_cast<double>(it->second);	 
      } catch (...) { //wyjatek lexical_cast 
	 throw Wyjatek("Blad w funkcji ustawParametry w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!");
      }
   }

   wariancja = tymczWar;
   konfiguracja["[war]="] = boost::lexical_cast<std::string>(tymczWar);
}


//------------------------------------------------------------------------------
//-------------- KONIEC [definicji klasy GeneratorLosowy] ----------------------
//------------------------------------------------------------------------------



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZ�TEK [definicji klasy GeneratorImpulsu] ++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//======= definicja skladnika statycznego liczbaGeneratorowImpulsu ============
/**
 * Skladnik statyczny do przechowywania aktualnej liczby obiektow 
 * GeneratoraLosowego
 */
int GeneratorImpulsu :: liczbaGeneratorowImpulsu = 0;

//======= konstruktor  =========================================================
/**
 * Konstruktor klasy GeneratorImpulsu.
 *      @param czas - czas skoku
 *		@param wartosc - wartosc skoku
 */
GeneratorImpulsu::GeneratorImpulsu (){
	jestZero = true;
	liczbaGeneratorowImpulsu++;
	stringstream strumien;
    strumien<<liczbaGeneratorowImpulsu;
    this->nazwa = "impuls" + strumien.str();
    konfiguracja["[nazwa]="] = this->nazwa;
    konfiguracja["[typ]="] = "Impuls";
}

//======= konstruktor kopiujacy ================================================
/**
 * Konstruktor kopiujacy klasy GeneratorImpulsu.
 *      @param &wzor - referencja do obiektu klasy GeneratorImpulsu, 
					   kt�ry ma by� skopiowany.
 */
GeneratorImpulsu::GeneratorImpulsu (const GeneratorImpulsu & wzor){
	this->jestZero = wzor.jestZero;
	liczbaGeneratorowImpulsu++;
	stringstream strumien;
    strumien<<liczbaGeneratorowImpulsu;
    this->nazwa = "impuls" + strumien.str();
}

//======= destruktor  ==========================================================
/**
 * Destruktor klasy GeneratorImpulsu - aktualizuje liczbe obiektow GeneratorImpulsu.
 */
GeneratorImpulsu :: ~GeneratorImpulsu(){
    liczbaGeneratorowImpulsu--;
}

//======= funkcja generuj ======================================================
/**
 * Funkcja generujaca probke sygnalu losowego o zadanej wariancji.
 *      @return probka generowanego sygnalu
 */
double GeneratorImpulsu::generuj(){
	if(jestZero) {
		jestZero = false;
		return 1.0;
	}
	else return 0.0;
}

//======= funkcja pobierzNazwe =================================================
/**
 * Funkcja zwracajaca nazwe obiektu klasy GeneratorImpulsu.
 *      @return nazwa
 */
std::string GeneratorImpulsu::pobierzNazwe() const{
	return nazwa;
}
    
//======= funkcja reset ========================================================
/**
 * Funkcja resetujaca generator. Zeruje numerProbki.
 */
void GeneratorImpulsu::reset(){
	jestZero = true;
}
//------------------------------------------------------------------------------
//-------------- KONIEC [definicji klasy GeneratorImpulsu] ----------------------
//------------------------------------------------------------------------------



void GeneratorImpulsu::ustawParam(std::map<std::string, std::string> konfig) {
   
}




//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZATEK [definicji klasy GeneratorSkoku] +++++++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//======= definicja skladnika statycznego liczbaGeneratorowLosowych ============
/**
 * Skladnik statyczny do przechowywania aktualnej liczby obiektow 
 * GeneratoraLosowego
 */
int GeneratorSkoku :: liczbaGeneratorowSkoku = 0;

//======= konstruktor  =========================================================
/**
 * Konstruktor klasy GeneratorSkoku.
 *      @param czas - czas skoku
 *		@param wartosc - wartosc skoku
 */
GeneratorSkoku::GeneratorSkoku (int czas, double wartosc){
	this->czasSkoku = czas;
	this->wartoscSkoku = wartosc;
	numerProbki = 0;
	liczbaGeneratorowSkoku++;
	stringstream strumien;
    strumien<<liczbaGeneratorowSkoku;
    this->nazwa = "skok" + strumien.str();
    konfiguracja["[nazwa]="] = this->nazwa;
    konfiguracja["[typ]="] = "Skok";
    konfiguracja["[czas]="] = "0";
    konfiguracja["[wartosc]="] = "0";
}

//======= konstruktor kopiujacy ================================================
/**
 * Konstruktor kopiujacy klasy GeneratorSkoku.
 *      @param &wzor - referencja do obiektu klasy GeneratorSkoku, 
					   ktory ma byc skopiowany
 */
GeneratorSkoku::GeneratorSkoku (const GeneratorSkoku & wzor){
	this->czasSkoku = wzor.czasSkoku;
	this->wartoscSkoku = wzor.wartoscSkoku;
	this->numerProbki = wzor.numerProbki;
	liczbaGeneratorowSkoku++;
	stringstream strumien;
    strumien<<liczbaGeneratorowSkoku;
    this->nazwa = "skok" + strumien.str();
}

//======= destruktor  ==========================================================
/**
 * Destruktor klasy GeneratorSkoku - aktualizuje liczbe obiektow GeneratorSkoku.
 */
GeneratorSkoku :: ~GeneratorSkoku(){
    liczbaGeneratorowSkoku--;
}

//======= funkcja generuj ======================================================
/**
 * Funkcja generujaca probke sygnalu losowego o zadanej wariancji.
 *      @return probka generowanego sygnalu
 */
double GeneratorSkoku::generuj(){
	//numerProbki++;
	if(numerProbki++>=czasSkoku) return wartoscSkoku;
	else return 0.0;
}

//======= funkcja pobierzNazwe =================================================
/**
 * Funkcja zwracajaca nazwe obiektu klasy GeneratorSkoku.
 *      @return nazwa
 */
std::string GeneratorSkoku::pobierzNazwe() const{
	return nazwa;
}
    
//======= funkcja reset ========================================================
/**
 * Funkcja resetujaca generator. Zeruje numerProbki.
 */
void GeneratorSkoku::reset(){
	numerProbki = 0;
}



void GeneratorSkoku::ustawParam(std::map<std::string, std::string> konfig) {

   double tymczCzas;
   double tymczWart;
   std::map<std::string,std::string>::iterator it;

   if(!sprawdzPoprawnoscMapy(konfig)) {
      throw Wyjatek("Blad w funkcji ustawParam w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!"
		       + "\n Brak klucza:" + it->first);
   }


   for (it = konfig.begin(); it != konfig.end(); ++it) {
      try {
	 if ((it->first) == ("[czas]="))
	    tymczCzas = boost::lexical_cast<double>(it->second);	 
	 else if ((it->first) == ("[wart]="))
	    tymczWart = boost::lexical_cast<double>(it->second);	 
      } catch (stringstream::failure e) { //wyjatek strumienia - nie wczytano poprawnie parametrow
	 throw Wyjatek("Blad w funkcji ustawParametry w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!");
      }
   }

   czasSkoku = tymczCzas;
   wartoscSkoku = tymczWart;
   konfiguracja["[czas]="] = boost::lexical_cast<std::string>(tymczCzas);
   konfiguracja["[wart]="] = boost::lexical_cast<std::string>(tymczWart);
}


//------------------------------------------------------------------------------
//-------------- KONIEC [definicji klasy GeneratorSkoku] -----------------------
//------------------------------------------------------------------------------



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZ�TEK [definicji klasy GeneratorProstokata] ++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//======= definicja skladnika statycznego liczbaGeneratorowProstokata ============
/**
 * Skladnik statyczny do przechowywania aktualnej liczby obiektow 
 * GeneratoraLosowego
 */
int GeneratorProstokata :: liczbaGeneratorowProstokata = 0;

//======= konstruktor  =========================================================
/**
 * Konstruktor klasy GeneratorProstokata.
 *      @param war1 - wartosc przy wlaczeniu
 *		@param war2 - wartosc przy wylaczeniu
 *		@okres okr - okres
 *		@param wyp - wypelnienie, ilosc probek po ktorej generator przejdzie w stan 
 *					 wylaczenia
 */
GeneratorProstokata::GeneratorProstokata (double war1, double war2, int okr, int wyp){
	this->wartoscWlaczony = war1;
	this->wartoscWylaczony = war2;
	this->okres = okr;
	this->wypelnienie = wyp;
	this->numerProbki = 0;
	liczbaGeneratorowProstokata++;
	stringstream strumien;
    strumien<<liczbaGeneratorowProstokata;
    this->nazwa = "prostokat" + strumien.str();
    konfiguracja["[nazwa]="] = this->nazwa;
    konfiguracja["[typ]="] = "Prostokat";
    konfiguracja["[war1]="] = "0";
    konfiguracja["[war2]="] = "0";
    konfiguracja["[okr]="] = "0";
    konfiguracja["[wyp]="] = "0";
}

//======= konstruktor kopiujacy ================================================
/**
 * Konstruktor kopiujacy klasy GeneratorProstokata.
 *      @param &wzor - referencja do obiektu klasy GeneratorProstokata, 
					   kt�ry ma by� skopiowany.
 */
GeneratorProstokata::GeneratorProstokata (const GeneratorProstokata & wzor){
	this->wartoscWlaczony = wzor.wartoscWlaczony;
	this->wartoscWylaczony = wzor.wartoscWylaczony;
	this->okres = wzor.okres;
	this->wypelnienie = wzor.wypelnienie;
	this->numerProbki = wzor.numerProbki;
	liczbaGeneratorowProstokata++;
	stringstream strumien;
    strumien<<liczbaGeneratorowProstokata;
    this->nazwa = "prostokat" + strumien.str();
}

//======= destruktor  ==========================================================
/**
 * Destruktor klasy GeneratorProstokata - aktualizuje liczbe obiektow GeneratorProstokata.
 */
GeneratorProstokata :: ~GeneratorProstokata(){
    liczbaGeneratorowProstokata--;
}

//======= funkcja generuj ======================================================
/**
 * Funkcja generujaca probke sygnalu losowego o zadanej wariancji.
 *      @return probka generowanego sygnalu
 */
double GeneratorProstokata::generuj(){
	if( numerProbki>=okres ) 
		numerProbki = 1;
	else
		numerProbki++;
	if( numerProbki<=wypelnienie )
		return wartoscWlaczony;
	else 
		return wartoscWylaczony;
}

//======= funkcja pobierzNazwe =================================================
/**
 * Funkcja zwracajaca nazwe obiektu klasy GeneratorProstokata.
 *      @return nazwa
 */
std::string GeneratorProstokata::pobierzNazwe() const{
	return nazwa;
}
    
//======= funkcja reset ========================================================
/**
 * Funkcja resetujaca generator. Zeruje numerProbki.
 */
void GeneratorProstokata::reset(){
	numerProbki = 0;
	
}




void GeneratorProstokata::ustawParam(std::map<std::string, std::string> konfig) {
   double tymczWar1;
   double tymczWar2;
   double tymczOkr;
   double tymczWyp;
   std::map<std::string,std::string>::iterator it;

   if(!sprawdzPoprawnoscMapy(konfig)) {
      throw Wyjatek("Blad w funkcji ustawParam w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!"
		       + "\n Brak klucza:" + it->first);
   }
   
   for (it = konfig.begin(); it != konfig.end(); ++it) {
      try {
	 if ((it->first) == ("[war1]="))
	    tymczWar1 = boost::lexical_cast<double>(it->second);
	 else if ((it->first) == ("[war2]="))
	    tymczWar2 = boost::lexical_cast<double>(it->second);
	 else if ((it->first) == ("[okr]="))
	    tymczOkr = boost::lexical_cast<double>(it->second);
	 else if ((it->first) == ("[wyp]="))
	    tymczWyp = boost::lexical_cast<double>(it->second);
      } catch (stringstream::failure e) { //wyjatek strumienia - nie wczytano poprawnie parametrow
	 throw Wyjatek("Blad w funkcji ustawParametry w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!");
      }
   }

   wartoscWlaczony = tymczWar1;
   wartoscWylaczony = tymczWar2;
   okres = tymczOkr;
   wypelnienie = tymczWyp;
   konfiguracja["[okr]="] = boost::lexical_cast<std::string>(tymczOkr);
   konfiguracja["[wyp]="] = boost::lexical_cast<std::string>(tymczWyp);
   konfiguracja["[war1]="] = boost::lexical_cast<std::string>(tymczWar1);
   konfiguracja["[war2]="] = boost::lexical_cast<std::string>(tymczWar2);
}

//------------------------------------------------------------------------------
//-------------- KONIEC [definicji klasy GeneratorProstokata] ------------------
//------------------------------------------------------------------------------



//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZ�TEK [definicji klasy GeneratorSinusa] ++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//======= definicja skladnika statycznego liczbaGeneratorowSinusa ============
/**
 * Skladnik statyczny do przechowywania aktualnej liczby obiektow 
 * GeneratoraLosowego
 */
int GeneratorSinusa :: liczbaGeneratorowSinusa = 0;

//======= konstruktor  =========================================================
/**
 * Konstruktor klasy GeneratorSinusa.
 *      @param amp - amplituda
 *		@okres okr - okres
 */
GeneratorSinusa::GeneratorSinusa (double amp, int okr){
	this->amplituda = amp;
	this->okres = okr;
	this->numerProbki = 0;
	liczbaGeneratorowSinusa++;
	stringstream strumien;
    strumien<<liczbaGeneratorowSinusa;
    this->nazwa = "sinus" + strumien.str();
    konfiguracja["[nazwa]="] = this->nazwa;
    konfiguracja["[typ]="] = "Prostokat";
    konfiguracja["[amp]="] = "0";
    konfiguracja["[okr]="] = "0";


	//------ generacja jednego okresu ------------------------------------
	for(int i=0; i<okres; i++){
		jedenOkresSygnalu.push_back( amplituda*sin(2.0*4.0*atan(1.0)/okres*i) );
	}
}
	
//======= konstruktor kopiujacy ================================================
/**
 * Konstruktor kopiujacy klasy GeneratorSinusa.
 *      @param &wzor - referencja do obiektu klasy GeneratorSinusa, 
					   kt�ry ma by� skopiowany.
 */
GeneratorSinusa::GeneratorSinusa (const GeneratorSinusa & wzor){
	this->amplituda = wzor.amplituda;
	this->okres = wzor.okres;
	this->numerProbki = wzor.numerProbki;
	this->jedenOkresSygnalu = wzor.jedenOkresSygnalu;
	liczbaGeneratorowSinusa++;
	stringstream strumien;
    strumien<<liczbaGeneratorowSinusa;
    this->nazwa = "sinus" + strumien.str();
}

//======= destruktor  ==========================================================
/**
 * Destruktor klasy GeneratorSinusa - aktualizuje liczbe obiektow GeneratorSinusa.
 */
GeneratorSinusa :: ~GeneratorSinusa(){
    liczbaGeneratorowSinusa--;
}

//======= funkcja generuj ======================================================
/**
 * Funkcja generujaca probke sygnalu losowego o zadanej wariancji.
 *      @return probka generowanego sygnalu
 */
double GeneratorSinusa::generuj(){
	int i = numerProbki++;
	if (numerProbki >= okres)
		numerProbki = 0;
	//return amplituda*sin(2.0*4.0*atan(1.0)/okres*numerProbki);
	return jedenOkresSygnalu.at(i);
}

//======= funkcja pobierzNazwe =================================================
/**
 * Funkcja zwracajaca nazwe obiektu klasy GeneratorSinusa.
 *      @return nazwa
 */
std::string GeneratorSinusa::pobierzNazwe() const{
	return nazwa;
}
    
//======= funkcja reset ========================================================
/**
 * Funkcja resetujaca generator. Zeruje numerProbki.
 */
void GeneratorSinusa::reset(){
	numerProbki = 0;
}



void GeneratorSinusa::ustawParam(std::map<std::string, std::string> konfig) {

   double tymczAmp;
   double tymczOkr;
   std::map<std::string,std::string>::iterator it;

   if(!sprawdzPoprawnoscMapy(konfig)) {
      throw Wyjatek("Blad w funkcji ustawParam w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!"
		       + "\n Brak klucza:" + it->first);
   }
   
   for (it = konfig.begin(); it != konfig.end(); ++it) {
      try {
	 if ((it->first) == ("[okr]="))
	    tymczOkr = boost::lexical_cast<double>(it->second);
	 else if ((it->first) == ("[amp]="))
	    tymczAmp = boost::lexical_cast<double>(it->second);
      } catch (stringstream::failure e) { //wyjatek strumienia - nie wczytano poprawnie parametrow
	 throw Wyjatek("Blad w funkcji ustawParametry w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!");
      }
   }

   okres = tymczOkr;
   amplituda = tymczAmp;
   konfiguracja["[okr]="] = boost::lexical_cast<std::string>(tymczOkr);
   konfiguracja["[amp]="] = boost::lexical_cast<std::string>(tymczAmp);
}

//------------------------------------------------------------------------------
//-------------- KONIEC [definicji klasy GeneratorSinusa] ----------------------
//------------------------------------------------------------------------------




//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//++++++++++++++ POCZ�TEK [definicji klasy GeneratorTrojkata] ++++++++++++++++
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

//======= definicja skladnika statycznego liczbaGeneratorowTrojkata ============
/**
 * Skladnik statyczny do przechowywania aktualnej liczby obiektow 
 * GeneratoraTrojkata
 */
int GeneratorTrojkata :: liczbaGeneratorowTrojkata = 0;

//======= konstruktor  =========================================================
/**
 * Konstruktor klasy GeneratorTrojkata.
 *      @param amp - amplituda
 *		@okres okr - okres (jezeli podany okres jest nieparzysty zostanie 
 *					 zmieniony na najblizsza wieksza liczbe parzysta)
 */
GeneratorTrojkata::GeneratorTrojkata (double amp, int okr){
	this->amplituda = amp;
	if (okr%2 == 1)	//podany okres jest nieparzysty
		okr++;		//zwiekszamy go o jeden
	this->okres = okr;
	this->numerProbki = 0;
	liczbaGeneratorowTrojkata++;
	stringstream strumien;
    strumien<<liczbaGeneratorowTrojkata;
    this->nazwa = "trojkat" + strumien.str();
    konfiguracja["[nazwa]="] = this->nazwa;
    konfiguracja["[typ]="] = "Prostokat";
    konfiguracja["[okr]="] = "0";
    konfiguracja["[amp]="] = "0";

	//------ generacja jednego okresu ------------------------------------
	for(int i=0; i<okres; i++){
		if ( i < static_cast<int>(okres/2.0) )
			jedenOkresSygnalu.push_back( amplituda-(4.0*amplituda/okres)*i );
		else
			jedenOkresSygnalu.push_back( -3.0*amplituda+(4.0*amplituda/okres)*i );
	}
}
	
//======= konstruktor kopiujacy ================================================
/**
 * Konstruktor kopiujacy klasy GeneratorTrojkata.
 *      @param &wzor - referencja do obiektu klasy GeneratorTrojkata, 
					   kt�ry ma by� skopiowany.
 */
GeneratorTrojkata::GeneratorTrojkata (const GeneratorTrojkata & wzor){
	this->amplituda = wzor.amplituda;
	this->okres = wzor.okres;
	this->numerProbki = wzor.numerProbki;
	this->jedenOkresSygnalu = wzor.jedenOkresSygnalu;
	liczbaGeneratorowTrojkata++;
	stringstream strumien;
    strumien<<liczbaGeneratorowTrojkata;
    this->nazwa = "trojkat" + strumien.str();
}

//======= destruktor  ==========================================================
/**
 * Destruktor klasy GeneratorTrojkata - aktualizuje liczbe obiektow GeneratorTrojkata.
 */
GeneratorTrojkata :: ~GeneratorTrojkata(){
    liczbaGeneratorowTrojkata--;
}

//======= funkcja generuj ======================================================
/**
 * Funkcja generujaca probke sygnalu losowego o zadanej wariancji.
 *      @return probka generowanego sygnalu
 */
double GeneratorTrojkata::generuj(){
	int i = numerProbki++;
	if (numerProbki >= okres)
		numerProbki = 0;
	//return amplituda*sin(2.0*4.0*atan(1.0)/okres*numerProbki);
	return jedenOkresSygnalu.at(i);
}

//======= funkcja pobierzNazwe =================================================
/**
 * Funkcja zwracajaca nazwe obiektu klasy GeneratorTrojkata.
 *      @return nazwa
 */
std::string GeneratorTrojkata::pobierzNazwe() const{
	return nazwa;
}
    
//======= funkcja reset ========================================================
/**
 * Funkcja resetujaca generator. Zeruje numerProbki.
 */
void GeneratorTrojkata::reset(){
	numerProbki = 0;
}




void GeneratorTrojkata::ustawParam(std::map<std::string, std::string> konfig) {

   double tymczAmp;
   double tymczOkr;
   std::map<std::string,std::string>::iterator it;

   if(!sprawdzPoprawnoscMapy(konfig)) {
      throw Wyjatek("Blad w funkcji ustawParam w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!"
		       + "\n Brak klucza:" + it->first);
   }
   
   for (it = konfig.begin(); it != konfig.end(); ++it) {
      try {
	 if ((it->first) == ("[okr]="))
	    tymczOkr = boost::lexical_cast<double>(it->second);
	 else if ((it->first) == ("[amp]="))
	    tymczAmp = boost::lexical_cast<double>(it->second);
      } catch (stringstream::failure e) { //wyjatek strumienia - nie wczytano poprawnie parametrow
	 throw Wyjatek("Blad w funkcji ustawParametry w obiekcie: " + this->pobierzNazwe()
		       + ".\n Nie zmieniono parametrow!");
      }
   }

   okres = tymczOkr;
   amplituda = tymczAmp;
   konfiguracja["[okr]="] = boost::lexical_cast<std::string>(tymczOkr);
   konfiguracja["[amp]="] = boost::lexical_cast<std::string>(tymczAmp);
}
//------------------------------------------------------------------------------
//-------------- KONIEC [definicji klasy GeneratorTrojkata] ----------------------
//------------------------------------------------------------------------------

